Fix #1027: clear stuck "Needs input" when the follow-up event turnId drifts - #5666

@RubiconPerform is attempting to deploy a commit to the Manaflow Team on Vercel.

A member of the Team first needs to authorize it.

No actionable comments were generated in the recent review. 🎉

❌ Failed checks (1 error, 1 warning, 1 inconclusive)

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

@codex review
@coderabbitai review
@greptile-apps review
@cubic-dev-ai review

@codex review
@coderabbitai review
@greptile-apps review
@cubic-dev-ai review

@RubiconPerform I can't start this review because your workspace has reached its free monthly review limit. Reviews resume at the start of your next billing cycle. Paid plans include much higher monthly review limits. Upgrade now to resume reviews.

#!/bin/bash
# Fetch the PR diff
gh pr view 5666 --repo manaflow-ai/cmux --json files,additions,deletions,changedFiles
echo "---DIFF---"
gh pr diff 5666 --repo manaflow-ai/cmux

@RubiconPerform — solid fix with a well-contained scope. The relaxed gate is correctly limited to same-session + needsInput state, the setting paths keep the strict guard, and the cross-session guardrail test mirrors the existing testClaudeStopFromPreviousSessionDoesNotClobberClearRunningStatus. A few things worth looking at:

🟡 Missing regression test for prompt-submit turn-drift

prompt-submit is listed as one of the three clearing transitions in the PR description, but there is no test for the turn-drift case analogous to the stop and pre-tool-use tests. Given the pattern of the other two tests, this should be straightforward to add:

func testClaudeNotificationNeedsInputClearsOnSameSessionTurnDriftPromptSubmit() throws {
    let context = try makeClaudeHookContext(name: "claude-needsinput-clear-promptsubmit")
    defer { context.cleanup() }

    let sessionId = "stuck-needsinput-promptsubmit-session"

    // Establish turn-1 as the active turn
    let promptSubmit1 = runClaudeHook(
        context: context,
        arguments: ["hooks", "claude", "prompt-submit"],
        standardInput: #"{"session_id":"\#(sessionId)","turn_id":"turn-1","cwd":"\#(context.root.path)","hook_event_name":"UserPromptSubmit","prompt":"continue"}"#
    )
    XCTAssertEqual(promptSubmit1.status, 0, promptSubmit1.stderr)

    // Notification leaves the session on needsInput with active turn still at turn-1
    let notification = runClaudeHook(
        context: context,
        arguments: ["hooks", "claude", "notification"],
        standardInput: #"{"session_id":"\#(sessionId)","cwd":"\#(context.root.path)","hook_event_name":"Notification","message":"Claude needs your permission"}"#
    )
    XCTAssertEqual(notification.status, 0, notification.stderr)
    XCTAssertEqual(
        try readClaudeHookSession(sessionId, context: context)["agentLifecycle"] as? String,
        "needsInput"
    )

    let cmdStart = context.state.commands.count
    // Same session, drifted turn id
    let promptSubmit2 = runClaudeHook(
        context: context,
        arguments: ["hooks", "claude", "prompt-submit"],
        standardInput: #"{"session_id":"\#(sessionId)","turn_id":"turn-2","cwd":"\#(context.root.path)","hook_event_name":"UserPromptSubmit","prompt":"yes"}"#
    )
    XCTAssertEqual(promptSubmit2.status, 0, promptSubmit2.stderr)

    XCTAssertEqual(
        try readClaudeHookSession(sessionId, context: context)["agentLifecycle"] as? String,
        "running",
        "A same-session prompt-submit with a drifted turn id must clear the stale needsInput to running"
    )
    let cmds = Array(context.state.commands.dropFirst(cmdStart))
    XCTAssertTrue(
        cmds.contains { $0.hasPrefix("set_agent_lifecycle claude_code running --tab=\(context.workspaceId)") },
        "Drifted prompt-submit must emit running lifecycle, saw \(cmds)"
    )
}

🟡 AskUserQuestion question-text gating is a new behavioral change

Before this PR, the AskUserQuestion branch inside pre-tool-use stored the question text whenever parsedInput.sessionId != nil, regardless of isCurrent. Now it additionally requires shouldApplyClaudeHookVisibleMutation(...) to be true:

// Before (implicit): question text stored whenever sessionId != nil
if let toolName = ...,
   toolName == "AskUserQuestion",
   let question = ...,
   let sessionId = parsedInput.sessionId { ... }

// After: question text also gated by the strict isCurrent check
   let sessionId = parsedInput.sessionId,
   shouldApplyClaudeHookVisibleMutation(...) { ... }

In the happy path this is fine, but consider a race where a pre-tool-use(AskUserQuestion) arrives with a drifted turnId (e.g., after a rapid resume). The strict gate would block storing the question text, so the subsequent Notification would fall back to the generic "Claude Code needs your attention" message instead of the actual question. If that's acceptable, it's worth an explicit comment; if not, the question-text storage could remain ungated while only the needsInput-setting mutation is gated:

// Option: always store question text, only gate the needsInput mutation
if let toolName = ...,
   toolName == "AskUserQuestion",
   let question = ...,
   let sessionId = parsedInput.sessionId {
    // Store question text unconditionally (used by Notification for display only)
    sessionStore.setQuestionText(question, for: sessionId)
    
    // Only mutate agentLifecycle when current
    if shouldApplyClaudeHookVisibleMutation(...) {
        sessionStore.setLifecycle(.needsInput, for: sessionId, workspaceId: workspaceId)
    }
}

🟢 Two lock acquisitions in isCurrentOrClearsStaleNeedsInput

isCurrent(...) and the fallback withLockedState { ... } each acquire the lock independently. This is fine for correctness (the result is used as an optimistic hint, not a critical section), but there's a theoretical TOCTOU window between the two calls if agentLifecycle transitions off needsInput concurrently. Given the existing lock structure this is probably acceptable, but worth a comment noting the two-phase read is intentional.

✅ Things that look correct

• The cross-session guardrail (active.sessionId == normalizedSessionId) is tight and correctly prevents a different-session event from clearing the active workspace's badge.
• shouldApplyClaudeHookClearingMutation error handling (return true) is consistent with the existing shouldApplyClaudeHookVisibleMutation pattern — failing open for clearing events is less risky than failing open for setting events.
• The normalizeOptional(workspaceId) call on a non-optional String is consistent with the existing isCurrent guard pattern.
• If isCurrent throws, isCurrentOrClearsStaleNeedsInput propagates the throw; shouldApplyClaudeHookClearingMutation catches it and returns true. This is the correct fail-open path for a clearing gate.

Greptile Summary

Fixes the stuck "Needs input" sidebar badge (issue #1027) by introducing isCurrentOrClearsStaleNeedsInput — a single-lock gate that relaxes the strict isCurrent check for the three clearing transitions (stop, prompt-submit, pre-tool-use) when the event is for the same active session but its turnId has drifted after a Notification. Cross-session events continue to fail closed.

• New gate is atomic: the previous double-withLockedState TOCTOU issue is resolved; isCurrent logic is fully inlined into one lock acquisition so the session-ID and needsInput checks can't race.
• AskUserQuestion restructured: handled before the relaxed clearing gate with a strict gate and an early return, so a drifted AskUserQuestion can never fall through to the running upsert and wipe a live "Needs input" badge.
• Five regression tests added: cover all three drifted clearing transitions, the cross-session guardrail, and the new AskUserQuestion-drift guardrail; closes coverage gaps flagged in earlier review rounds.

Confidence Score: 5/5

The change is safe to merge; the gate logic is atomic, the cross-session guardrail is preserved, and all three clearing transitions now have regression coverage including the previously missing prompt-submit and AskUserQuestion-drift cases.

The atomicity issue (double withLockedState) and the AskUserQuestion fall-through regression identified in earlier rounds are both fully addressed. The new gate is self-contained and the test suite explicitly covers the same-session/drifted, cross-session, and AskUserQuestion-drift scenarios. The only remaining gap — partial locale coverage in the string catalog — is consistent with the established pattern for the entire agent.* namespace and does not affect functionality.

No files require special attention for merging; the Localizable.xcstrings locale gap is a follow-up quality item.

Important Files Changed

Sequence Diagram

sequenceDiagram
    participant C as Claude CLI
    participant G as Gate (shouldApplyClaudeHookClearingMutation)
    participant S as ClaudeHookSessionStore
    participant UI as Sidebar Badge

    Note over C,UI: Happy path — same session, same turnId
    C->>G: "stop(sessionId=S1, turnId=T1)"
    G->>S: isCurrentOrClearsStaleNeedsInput (single withLockedState)
    S-->>G: "active.sessionId==S1, activeTurnId==T1 → true"
    G-->>C: allow
    C->>UI: set_agent_lifecycle idle

    Note over C,UI: Bug 1027 — same session, drifted turnId, needsInput
    C->>G: "stop(sessionId=S1, turnId=T2)"
    G->>S: isCurrentOrClearsStaleNeedsInput (single withLockedState)
    S-->>G: "active.sessionId==S1, activeTurnId≠T2, lifecycle==needsInput → true"
    G-->>C: allow (relaxed gate)
    C->>UI: set_agent_lifecycle idle — badge cleared

    Note over C,UI: Guardrail — different session
    C->>G: "stop(sessionId=S2, turnId=T9)"
    G->>S: isCurrentOrClearsStaleNeedsInput (single withLockedState)
    S-->>G: "active.sessionId==S1 ≠ S2 → false"
    G-->>C: block
    C->>UI: no mutation — S1 stays on needsInput

_{Reviews (6): Last reviewed commit: "Address review: localize the Claude "Wai..." | Re-trigger Greptile}

Greptile Summary

Adds a relaxed clearing gate (isCurrentOrClearsStaleNeedsInput) used only by the three lifecycle-clearing hook events (stop, prompt-submit, pre-tool-use), so a same-session follow-up event whose turnId drifted after a Notification can still clear a stale "Needs input" badge. The needsInput-setting paths keep the strict isCurrent gate.

• ClaudeHookSessionStore.isCurrentOrClearsStaleNeedsInput delegates first to isCurrent and on failure makes a second withLockedState check for agentLifecycle == .needsInput; this two-lock pattern is non-atomic.
• shouldApplyClaudeHookClearingMutation mirrors shouldApplyClaudeHookVisibleMutation but calls the relaxed gate; the AskUserQuestion branch gains its own strict guard.
• Three integration regression tests are added; the prompt-submit turn-drift path is not yet covered.

Confidence Score: 3/5

The different-session guard is correct, but the new isCurrentOrClearsStaleNeedsInput acquires flock twice non-atomically, leaving a race window where concurrent hook processes can observe inconsistent state.

The new isCurrentOrClearsStaleNeedsInput acquires the file lock twice non-atomically — isCurrent takes and releases flock, then the caller takes it again for the agentLifecycle check. A concurrent hook process can write between those two acquisitions, making the gate read stale state and potentially allow or block a clearing transition incorrectly.

CLI/cmux.swift — specifically the new isCurrentOrClearsStaleNeedsInput method and its double-lock pattern.

Important Files Changed

_{Reviews (1): Last reviewed commit: "Fix #1027: clear a stuck "Needs input" w..." | Re-trigger Greptile}

Greptile Summary

This PR fixes the "Needs input" badge getting permanently stuck in the sidebar by introducing a relaxed clearing gate (isCurrentOrClearsStaleNeedsInput) that allows stop, prompt-submit, and pre-tool-use events to clear a stale needsInput state even when the event's turnId has drifted from the workspace's active turn — a condition caused by Notification events not advancing the active turn pointer.

• New gate function ClaudeHookSessionStore.isCurrentOrClearsStaleNeedsInput returns true for same-session events when the session is stuck on .needsInput, bypassing the strict turnId check; different-session events still fail closed.
• Three clearing handlers (stop, prompt-submit, pre-tool-use) are switched from shouldApplyClaudeHookVisibleMutation to the new shouldApplyClaudeHookClearingMutation wrapper; the AskUserQuestion branch in pre-tool-use retains the strict gate.
• Three integration tests validate same-session turn-drift clearing for stop and pre-tool-use, plus the different-session guardrail; a prompt-submit turn-drift test is missing.

Confidence Score: 3/5

The relaxed clearing gate introduces a regression in the pre-tool-use handler: when Claude follows a Notification with an AskUserQuestion in a new turn, the stale-needsInput fallback fires the clearing path and the badge incorrectly transitions to Running instead of Needs input, a state the sidebar cannot recover from without another user interaction.

The stop and prompt-submit paths are straightforward and the relaxation is safe there. The pre-tool-use path is more complex because it has two diverging outcomes depending on the tool name. The clearing gate is applied before the tool-name check, so a drifted-turnId AskUserQuestion event passes the clearing guard, the strict AskUserQuestion branch is then skipped, and lifecycle lands on .running. Because the following Notification is also gated out by the strict check, the badge is stranded at Running — worse than the pre-fix stuck-needsInput behavior.

CLI/cmux.swift — specifically the pre-tool-use handler around the AskUserQuestion branch (lines 22110–22169) where the new clearing gate and the strict AskUserQuestion gate interact.

Important Files Changed

Sequence Diagram

sequenceDiagram
    participant U as User
    participant CH as Claude Hook CLI
    participant SS as ClaudeHookSessionStore
    participant UI as Sidebar Badge

    Note over CH,UI: Bug scenario (pre-fix): turnId drift strands Needs input
    U->>CH: prompt-submit (turn-1)
    CH->>SS: upsert(turn-1, running)
    CH->>UI: running

    CH->>SS: notification → needsInput (turn stays turn-1)
    CH->>UI: Needs input

    CH->>SS: stop(turn-2, same session)
    SS-->>CH: "isCurrent=false (turn-2 ≠ turn-1)"
    Note over CH: gated out — badge stranded

    Note over CH,UI: Fix: isCurrentOrClearsStaleNeedsInput relaxes clearing gate
    CH->>SS: stop(turn-2, same session)
    SS-->>CH: "isCurrent=false, but needsInput+same session → true"
    CH->>SS: upsert(idle)
    CH->>UI: idle

    Note over CH,UI: Regression: pre-tool-use AskUserQuestion + drifted turnId
    CH->>SS: pre-tool-use(AskUserQuestion, turn-2)
    SS-->>CH: clearing gate passes (needsInput fallback)
    Note over CH: strict AskUserQuestion check fails (turn-2 ≠ turn-1)
    CH->>SS: upsert(running) falls through
    CH->>UI: Running (wrong)
    CH->>SS: notification(turn-2) — strict gate fails, gated out
    Note over UI: Badge stranded at Running

_{Reviews (3): Last reviewed commit: "Fix #1027: clear a stuck "Needs input" w..." | Re-trigger Greptile}

Pushed 076c85f9a addressing the review feedback — thanks both.

@codex (P2 — a drifted AskUserQuestion could clear "Needs input"): Confirmed, good catch, and fixed. AskUserQuestion is a needsInput-setting event, so it's now handled before the relaxed clearing gate and always returns. A drifted/stale AskUserQuestion therefore leaves state as-is instead of falling through to the generic .running path and wiping a live "Needs input". Raising needsInput keeps the strict isCurrent gate; the relaxed clearing gate now governs only non-AskUserQuestion pre-tool-use (Claude resuming work → running). Added testClaudeAskUserQuestionWithDriftedTurnDoesNotClearNeedsInput to lock it in.

@coderabbitai:

• Added the missing prompt-submit turn-drift test — testClaudeNotificationNeedsInputClearsOnSameSessionTurnDriftPromptSubmit (the third clearing transition, alongside the stop and pre-tool-use cases).
• Documented the intentional two-phase read in isCurrentOrClearsStaleNeedsInput (optimistic gate hint, not a critical section — a benign TOCTOU there can only ever clear a stale badge, never the reverse).

Both changed files are swiftc -parse clean. The full cmux-unit suite still needs Xcode 26 (I only have Xcode 15 locally), so I'm relying on CI to run the integration tests.

@codex review
@coderabbitai review

#!/bin/bash
gh pr diff 5666 --repo manaflow-ai/cmux

@RubiconPerform — all three items verified in the diff. Everything looks correct:

1. prompt-submit turn-drift test ✅ — testClaudeNotificationNeedsInputClearsOnSameSessionTurnDriftPromptSubmit is present and follows the same structure as the stop and pre-tool-use companions.

2. AskUserQuestion early-return ✅ — Moving it before the relaxed gate and always returning is cleaner than the "option" I sketched. The else branch emits claude-hook.pre-tool-use.ask-user-question.skipped for observability on the drifted/not-current path. testClaudeAskUserQuestionWithDriftedTurnDoesNotClearNeedsInput locks it in as a regression test.

3. Two-phase read comment ✅ — The inline comment in isCurrentOrClearsStaleNeedsInput is precise: "A benign TOCTOU can at most let a clearing event proceed against a needsInput that just changed — which only ever clears a stale badge, never the reverse."

The five new tests collectively cover all three clearing transitions under turn drift, the cross-session guardrail, and the AskUserQuestion non-clearing invariant. Looks good to merge pending CI.

🐇 ✨

[resolve]

Pushed 05d62c5f0 addressing the latest round — thanks for the thorough pass.

Atomic gate (@greptile P1, @coderabbitai Major): isCurrentOrClearsStaleNeedsInput now inlines the isCurrent predicate into a single withLockedState snapshot, so the turn-identity check and the needsInput check are evaluated atomically and can't race a concurrent session update between two lock windows. This also removes the post-isCurrent re-normalization guard that @greptile flagged as unreachable dead code — it's gone with the refactor.

Distinct breadcrumb (@greptile P2): the clearing gate now emits claude-hook.clearing-gate.error instead of colliding with the strict gate's claude-hook.is-current.error.

Already in 076c85f9a (you were reviewing the first commit ed5db2578): the missing prompt-submit turn-drift test is added, and the AskUserQuestion fall-through (@codex P2) is fixed — it's now handled as a needsInput-setting event before the relaxed gate and always returns, so a drifted AskUserQuestion can't fall through to running and clear the badge (covered by testClaudeAskUserQuestionWithDriftedTurnDoesNotClearNeedsInput).

"Advance the active turn" / "symptom patch" (@codex P2, @greptile P2): agreed these describe the more complete model. I've kept this PR scoped to the stuck-badge root cause deliberately: (a) the turn-non-advancement is pre-existing, not introduced here; (b) advancing active.turnId on clearing events reaches into the turn-stack machinery (markActive / activePromptTurnIds) where I'd rather not risk side-effects as an outside contributor; and (c) the Notification payload that sets needsInput doesn't reliably carry a turnId to "carry forward." Happy to do the turn-advancement refactor as a follow-up if you'd prefer it over the gate approach.

Waiting subtitle (@coderabbitai): that string is pre-existing — I relocated the block, didn't add it — so I've left localizing it out of scope for this bugfix.

Verification: built and ran the cmux-unit suite locally under Xcode 16.4 / Swift 6.1 — the change compiles clean and 144 tests pass. The remaining failures in my run (including the pre-existing testClaudeStopFromPreviousSessionDoesNotClobberClearRunningStatus and ~10 unrelated SSH/Tmux/Grok tests) are a local test-host control-socket issue: surface.list goes unanswered (mobile host listener disabled; publishing XCTest routes without binding), so every socket-driven hook times out at 15s regardless of the diff. Relying on CI for the integration tests. The gate logic itself I validated with a standalone harness (same-session-drift clears, different-session blocked, non-needsInput not over-cleared, same-turn unchanged).

@codex review
@coderabbitai review

#!/bin/bash
gh pr diff 5666 --repo manaflow-ai/cmux

@RubiconPerform — commit 05d62c5f0 addresses all three open items cleanly:

1. Atomic gate ✅ — isCurrentOrClearsStaleNeedsInput now evaluates the turn-identity check and the .needsInput check inside a single withLockedState closure; the prior two-phase read (and the now-unreachable re-normalization guard) are gone. The logic path is straightforward:

   • nil sessionId/workspace → fail open (consistent with isCurrent)
   • no active session for workspace → true
   • cross-session → false (guardrail intact)
   • turn match → true
   • turn drift, same session → return state.sessions[id]?.agentLifecycle == .needsInput

2. Distinct breadcrumb ✅ — shouldApplyClaudeHookClearingMutation now emits claude-hook.clearing-gate.error, no collision with claude-hook.is-current.error.

3. Five regression tests ✅ — all three clearing transitions under same-session drift (stop, pre-tool-use, prompt-submit), the cross-session guardrail, and the AskUserQuestion non-clearing invariant are covered. The testClaudeAskUserQuestionWithDriftedTurnDoesNotClearNeedsInput test also locks in the codex review finding from the first revision.

The AskUserQuestion refactor (early-return before the relaxed gate, skipped breadcrumb on the drift path) is a nice structural improvement over the "option" sketched earlier. Ready to merge pending CI green.

🐇 ✨

[resolve]

All concerns from the previous round are addressed in 05d62c5f0.

P1 items — fully resolved:

• Atomic gate: isCurrentOrClearsStaleNeedsInput now inlines all the isCurrent conditions into a single withLockedState closure. The turn-identity check and the agentLifecycle == .needsInput check are evaluated atomically against the same snapshot — no race window between two lock acquisitions.
• AskUserQuestion fall-through: Handled as its own branch before the relaxed clearing gate, unconditionally exits with print("OK"); return. A drifted AskUserQuestion can no longer fall through to the running path.

P2 items — resolved:

• Distinct breadcrumb: shouldApplyClaudeHookClearingMutation now emits claude-hook.clearing-gate.error, distinct from the strict gate's key.
• Dead code removed: The unreachable re-normalization guard is gone — the refactored single-lock implementation makes it unnecessary.
• Missing tests: Both the prompt-submit turn-drift test (testClaudeNotificationNeedsInputClearsOnSameSessionTurnDriftPromptSubmit) and the AskUserQuestion drift guardrail (testClaudeAskUserQuestionWithDriftedTurnDoesNotClearNeedsInput) are now present. Full coverage across all three clearing transitions + the two non-clearing guardrails.

Remaining P2 "symptom patch" concern: The reasoning is sound — Notification payloads don't reliably carry a turnId to advance the active turn, and touching markActive/activePromptTurnIds from outside the core turn-stack would carry unquantified side-effect risk. A follow-up to advance active.turnId on clearing events would be the cleaner long-term approach, but this PR is correctly scoped to the observable regression.

The implementation is clean, atomic, and well-tested. LGTM. ✅

Tip: You can customize Greptile's behavior for this repo with .greptile/rules.md and .greptile/config.json.

@austinywang (you're assigned #1027) — status summary + one design call I'd like your steer on, plus a heads-up that the Swift CI needs a maintainer to approve the workflow run on this fork PR.

Bot threads that are already addressed (re-flagged on a stale snapshot)

A few open threads are re-posts of items fixed in later commits — flagging so they're not read as still-open:

• "Non-atomic / double withLockedState" + "stale-needsInput fallback dead code" (Greptile P1/P2 @ :1258/:1260/:1257) → fixed in 05d62c5f0: isCurrentOrClearsStaleNeedsInput now inlines the isCurrent predicate into a single withLockedState (atomic; the dead guard is gone).
• "Duplicate breadcrumb key" (Greptile P2 @ :22416) → fixed in 05d62c5f0 (claude-hook.clearing-gate.error).
• "prompt-submit turn-drift untested" (Greptile P2 @ :399/:403) → added in 076c85f9a (testClaudeNotificationNeedsInputClearsOnSameSessionTurnDriftPromptSubmit).
• AskUserQuestion fall-through (codex P2) → fixed in 076c85f9a (handled as a setting event before the relaxed gate, with a regression test).

The one I want your call on — @chatgpt-codex-connector's :1256 is a real catch

The relaxed gate keys off "same session + needsInput + turn mismatch", which clears on any turn drift — including an older, late stop/pre-tool-use for a stale turn while a newer turn is the one actually showing the prompt. The strict isCurrent previously blocked that, so as written the fix trades the persistent stuck-badge for a rare transient wrong-clear on out-of-order same-session events. Two ways forward:

1. Tighten the gate to relax only for the current/latest turn, not older stale ones — but doing that correctly needs the turn-stack semantics (activePromptTurnIds / terminalPromptTurnIds / lastPromptTurnId), which I'd rather not guess at from outside.
2. Greptile's root-cause alternative — advance active.turnId in the Notification handler so isCurrent stays the single gate for every transition (no relaxation, so :1256 can't happen). This hinges on whether the Notification payload reliably carries the waiting turn's id — you'd know that better than I do.

I'm happy to implement whichever you prefer — (2) looks cleanest if Notification carries a turnId. Which direction do you want?

Verification

Built + ran cmux-unit locally under Xcode 16.4 / Swift 6.1: compiles clean, 144 tests pass. The remaining failures in my run (including the pre-existing testClaudeStopFromPreviousSessionDoesNotClobberClearRunningStatus and ~10 unrelated SSH/Tmux/Grok tests) are a local test-host socket issue — surface.list goes unanswered (mobile host listener disabled; publishing XCTest routes without binding), so every socket-driven hook times out regardless of the diff. So the integration tests need CI to validate, which needs a maintainer to approve the run. Gate logic itself is covered by a standalone harness.

To use Codex here, create an environment for this repo.

Localized the Waiting subtitle in 1733504a2 — String(localized: "agent.claude.input.subtitle.waiting", defaultValue: "Waiting") plus en/ja entries in Localizable.xcstrings, mirroring the existing agent.codex.input.subtitle.waiting convention. Build verified under Xcode 16.4. Thanks @coderabbitai.

@RubiconPerform — nice follow-through. Mirroring agent.codex.input.subtitle.waiting is exactly the right pattern, and adding both en and ja entries keeps the localization table complete. That ties off the last open thread from my earlier review.

🐇 🌸

If you found this review helpful, would you consider giving us a shout-out on X?

Thank you for using CodeRabbit!